class UnionFind {
  constructor(size) {
    this.parent = new Array(size + 1); // 电站编号1~c
    this.minOnline = new Array(size + 1); // 存储当前分量的最小在线电站（-1表示无）
    for (let i = 0; i <= size; i++) {
      this.parent[i] = i;
      this.minOnline[i] = -1; // 初始全部离线
    }
  }

  find(x) {
    if (this.parent[x] !== x) {
      this.parent[x] = this.find(this.parent[x]); // 路径压缩
    }
    return this.parent[x];
  }

  union(x, y) {
    let rootX = this.find(x);
    let rootY = this.find(y);
    if (rootX === rootY) return;

    // 合并：将rootY合并到rootX（合并方向不影响，关键是minOnline的更新）
    this.parent[rootY] = rootX;

    // 合并时的minOnline更新：取两个分量的最小值（-1表示无在线电站）
    if (this.minOnline[rootX] === -1 && this.minOnline[rootY] === -1) {
      this.minOnline[rootX] = -1;
    } else if (this.minOnline[rootX] === -1) {
      this.minOnline[rootX] = this.minOnline[rootY];
    } else if (this.minOnline[rootY] === -1) {
      this.minOnline[rootX] = this.minOnline[rootX];
    } else {
      this.minOnline[rootX] = Math.min(
        this.minOnline[rootX],
        this.minOnline[rootY]
      );
    }
  }

  // 激活电站x：将x设为在线，并更新所在分量的最小在线值
  activate(x) {
    const root = this.find(x);
    if (this.minOnline[root] === -1) {
      this.minOnline[root] = x;
    } else {
      this.minOnline[root] = Math.min(this.minOnline[root], x);
    }
  }

  // 获取x所在分量的最小在线电站
  getMin(x) {
    return this.minOnline[this.find(x)];
  }

  // 关键新增：判断电站x是否在线（通过离线计数辅助）
  isOnline(x, offlineCount) {
    return offlineCount[x] === 0;
  }
}

/**
 * 适配运行环境的函数名：processQueries
 * @param {number} c
 * @param {number[][]} connections
 * @param {number[][]} queries
 * @return {number[]}
 */
var processQueries = function (c, connections, queries) {
  const offlineCount = new Array(c + 1).fill(0);
  // 统计每个电站被离线的次数（可能多次离线，实际只需处理一次激活）
  for (const q of queries) {
    if (q[0] === 2) {
      offlineCount[q[1]]++;
    }
  }

  const uf = new UnionFind(c);

  // 第一步：先构建电网的连通分量（合并所有电缆连接）—— 关键修复：顺序颠倒
  for (const [u, v] of connections) {
    uf.union(u, v);
  }

  // 第二步：再激活所有初始在线的电站（未被任何离线查询标记的）
  for (let x = 1; x <= c; x++) {
    if (offlineCount[x] === 0) {
      uf.activate(x);
    }
  }

  const reversedResults = [];
  // 第三步：反向处理查询
  for (let i = queries.length - 1; i >= 0; i--) {
    const [type, x] = queries[i];
    if (type === 1) {
      // 维护查询：判断x是否在线，在线则返回x，否则返回分量最小在线值
      if (uf.isOnline(x, offlineCount)) {
        reversedResults.push(x);
      } else {
        reversedResults.push(uf.getMin(x));
      }
    } else {
      // 离线查询转为在线操作：减少离线计数，为0时激活
      offlineCount[x]--;
      if (offlineCount[x] === 0) {
        uf.activate(x);
      }
    }
  }

  // 反转结果，恢复原查询顺序
  return reversedResults.reverse();
};
